/**
 * 
 */
package model.core.torneo.calendario.algorithm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;



/**
 * @author Giuseppe Fusco (fusgius@gmail.com)
 *
 */
public abstract class BergerAlgorithm {

	public final List<? extends Object> generate(List<? extends Object> obj){

		List<? extends Object> gare_andata = new ArrayList<Object>();
		List<? extends Object> gare_ritorno = new ArrayList<Object>();

		if(obj.size() % 2!=0)
			obj.add(null);
		int num_g = obj.size();
		int days = num_g-1;
		Object[] in = new Object[num_g/2];
		Object[] out = new Object[num_g/2];
		for(int i=0; i<num_g/2; i++){
			in[i] = obj.get(i);
			out[i] = obj.get(num_g-1-i);
		}
		for(int i=0; i<days; i++){
			// alterna le partite in casa e fuori
			if(i%2==0){
				for(int j=0; j<num_g/2; j++){
					/*Object gara = new Object();
					gara.addGiocatore(out[j]);
					gara.addGiocatore(in[j]);
					gare.add(gara);*/
				}
			}else{
				for(int j=0; j<num_g/2; j++){
					/*Gara gara = new Gara();
					gara.addGiocatore(in[j]);
					gara.addGiocatore(out[j]);
					gare.add(gara);*/
				}
			}
			List<Object> in_list = Arrays.asList(in);
			List<Object> out_list = Arrays.asList(out);

			// Ruota in gli elementi delle liste, tenendo fisso il primo elemento
			Collections.rotate(in_list.subList(1, in_list.size()), -1);
			Collections.rotate(out_list.subList(1, out_list.size()), -1);
			for(int k=1; k<in_list.size(); k++){
				in[k] = in_list.get(k);
				out[k] = out_list.get(k);
			}

			// Salva l'elemento fisso
			Object pivot = in[0];

			out_list = Arrays.asList(out);

			//  sposta in avanti gli elementi di "trasferta" inserendo 
			//   all'inizio l'elemento casa[1] e salva l'elemento uscente in "riporto"
			Collections.rotate(out_list, 1);
			for(int z=0; z<out_list.size(); z++)
				out[z] = out_list.get(z);
			Object riporto = out[0];
			out[0] = in[1];

			in_list = Arrays.asList(in);
			Collections.rotate(in_list, -1);
			for(int z=0; z<in_list.size(); z++)
				in[z] = in_list.get(z);
			in[in.length-1] = riporto;

			// ripristina l'elemento fisso
			in[0] = pivot;
		}

		// genera il girone di ritorno
		List<Object> gare_compl = new ArrayList<Object>();
		for(Object g: gare_andata)
			gare_compl.add(g);
		for(Object g: gare_ritorno)
			gare_compl.add(g);
		
		
		return gare_compl;
	}
}
